package com.browsesoft.baseadapter;

import java.lang.reflect.Method;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.w3c.dom.Text;

import com.aote.model.Condition;
import com.aote.util.ExpressionHelper;
import com.browsesoft.Entity;
import com.browsesoft.EntityManager;
import com.browsesoft.ExtendElement;
import com.browsesoft.Tools;
import com.browsesoft.htmlcomponent.HTMLBasicComponent;
import com.browsesoft.htmlcomponent.Template;
import com.browsesoft.htmlcomponent.TemplateManager;
import com.browsesoft.noshow.NoShow;
import com.browsesoft.oa.FunctionColumn;
import com.browsesoft.oa.LookFilter;
import com.browsesoft.oa.MoreDelete;
import com.browsesoft.resource.Resource;
import com.browsesoft.resource.ResourceTool;
import com.browsesoft.resource.Right;
import com.browsesoft.resource.RightType;
import com.browsesoft.user.User;

/**
 * 单表数据维护表格组件，如果参数中有实体类型，优先使用，否则，从模板中取
 * 
 * 实现FunctionColumn说明基本表格可以转换成桌面栏目
 */
public class HTMLBasicTableModel implements HTMLTableModelAdapter,
		FunctionColumn {
	/**
	 * Model所对应的component
	 */
	public HTMLBasicComponent component = null;

	/**
	 * 父id
	 */
	protected String parentID;

	/**
	 * 从表中取得的所有数据
	 */
	protected List datas = new LinkedList();

	/**
	 * 要显示的所有字段中文名
	 */
	protected LinkedList cnames = new LinkedList();

	/**
	 * 页面所有元素
	 */
	protected LinkedList elements = new LinkedList();

	/**
	 * 实体类型
	 */
	protected String entityType;

	/**
	 * 要显示的所有字段英文名
	 */
	protected LinkedList enames = new LinkedList();

	/**
	 * 字段英文名与该字段配置
	 * 
	 */
	protected Hashtable fieldExpress = new Hashtable();

	/**
	 * 查询条件
	 */
	protected Hashtable condition = new Hashtable();

	/**
	 * 登录用户
	 */
	protected User loginUser = null;

	/**
	 * 居左，居右
	 */
	protected LinkedList bsalign = new LinkedList();

	/**
	 * 变化集合
	 */
	protected LinkedList changed = new LinkedList();

	/**
	 * 数据过滤器
	 */
	private LookFilter filter;

	/**
	 * 所对应的form表单的根元素
	 */
	protected Element formElement;

	/**
	 * 不显示设置器
	 */
	private Map nowShowMachines = new HashMap();;

	/**
	 * 初始化model
	 * 
	 * @param request
	 *            请求
	 * @throws Exception
	 */
	public void init(HttpServletRequest request) throws Exception {
		parentID = request.getParameter("point");
		this.formElement = this.getFormElement();
		// 该方法将取得实体类型
		if (this.formElement != null) {
			this.getTemplate(this.formElement);
		}
		this.entityType = this.getEntityType(request);
		// 取用户
		loginUser = (User) request.getSession().getAttribute("loginUser");
		// 如果有设置不显示配置
		gatherNoShowMachines();

	}

	/**
	 * 收集不显示设置器
	 */
	private void gatherNoShowMachines() {
		try {
			NodeList list = this.component.getPage().getElement()
					.getElementsByTagName("noshow");
			for (int i = 0; i < list.getLength(); i++) {
				Element elem = (Element) list.item(i);
				String className = elem.getAttribute("classname");
				NoShow show = (NoShow) Class.forName(className).newInstance();
				this.nowShowMachines.put(show, elem);
			}
		} catch (InstantiationException e) {
			throw new RuntimeException(e);
		} catch (IllegalAccessException e) {
			throw new RuntimeException(e);
		} catch (ClassNotFoundException e) {
			throw new RuntimeException(e);
		}
	}

	/**
	 * 得到实体类型
	 */
	private String getEntityType(HttpServletRequest request) {
		// 如果参数中有实体类型
		String str = request.getParameter("entitytype");
		if (str != null && !str.equals("")) {
			return str;
		}
		String type = this.component.getElement().getAttribute("entitytype");
		return type;
	}

	/**
	 * 得到列数
	 * 
	 * @return 列数
	 */
	public int getColumnCount() {
		// 如果有行标记
		if (hasRowNumber()) {
			return cnames.size() + 1;
		}
		return cnames.size();
	}

	/**
	 * 判断是否有行标记
	 */
	protected boolean hasRowNumber() {
		// 取得页面行标记
		String rownumber = this.component.getElement()
				.getAttribute("rownumber");
		// 如果有行标记
		if (rownumber != "" && rownumber.equals("rownumber")) {
			return true;
		} else {
			return false;
		}
	}

	/**
	 * 得到列的名称
	 * 
	 * @param index
	 *            列号
	 * @return 列的名称
	 */
	public String getColumnName(int index) {
		// 如果有行标记
		if (hasRowNumber()) {
			// 如果是第零列
			if (index == 0) {
				return "行号";
			} else if (index < cnames.size() + 1) {
				return (String) cnames.get(index - 1);
			} else {
				return "";
			}
		}
		// 否则
		else {
			if (index < cnames.size()) {
				return (String) cnames.get(index);
			} else {
				return "";
			}
		}
	}

	/**
	 * 得到列的英文名
	 * 
	 * @param index
	 *            列号
	 * @return 列的英文名
	 */
	public String getColumnEname(int index) {
		if (index < enames.size()) {
			return (String) enames.get(index);
		} else {
			return "";
		}
	}

	public Object getDatas() {
		return this.datas;
	}

	/**
	 * 得到行数
	 * 
	 * @return 行数
	 */
	public int getRowCount() {
		return datas.size();
	}

	/**
	 * 设置传递的参数
	 * 
	 * @param request
	 *            请求
	 * @param response
	 *            响应
	 * @throws Exception
	 */
	public void service(HttpServletRequest request, HttpServletResponse response)
			throws Exception {
		// 取组件元素中的条件
		Element e = this.component.getElement();
		String cond = e.getAttribute("condition");
		// 如果条件不为空
		if (cond != null && !cond.equals("")) {
			int index = cond.indexOf("#loginuser#");
			// 如果有#loginuser#
			if (index != -1) {
				// 替换用户id号
				String userid = loginUser.getID();
				cond = cond.replaceAll("#loginuser#", userid);
				e.setAttribute("condition", cond);
			}
		}
		// 取得是否真正提交
		String action = request.getParameter("action");
		// 批量删除
		this.deleteEntity(request, action, this.component);
		this.initData(request);
		// 如果action值为serialnumber,设置对象的编号属性
		if (action != null && action.equals("serialnumber")) {
			Map map = request.getParameterMap();
			Iterator it = map.keySet().iterator();
			this.insertSerialNumber(it, map);
		}
		// 不显示过滤
		this.datas = (LinkedList) filterNoShow();
		// 实现排序功能
		this.SortDatas();
	}

	/**
	 * 设置不显示
	 */
	private List filterNoShow() {
		List result = new LinkedList();
		result.addAll(this.datas);
		Iterator iter = this.nowShowMachines.keySet().iterator();
		while (iter.hasNext()) {
			NoShow show = (NoShow) iter.next();
			Element elem = (Element) this.nowShowMachines.get(show);
			result = show.filterShow(elem, result, this.component);
		}
		return result;
	}

	/**
	 * 得到数据，包括条件
	 * 
	 * @param request
	 * @throws Exception
	 */
	private void initData(HttpServletRequest request) throws Exception {
		this.datas = getData(request);
		// 添加用户输入的条件
		if (!condition.isEmpty()) {
			// 得到查询结果
			this.datas = (LinkedList) BSQuery.getSearchDatas(datas, condition);
		}
		// 如果配置有过滤器
		if (this.filter != null) {
			this.datas = this.filter.filter(this.loginUser, this.component,
					this.datas, request);
		}
		// 得到过滤条件
		String condition = this.component.getElement()
				.getAttribute("condition");
		// 如果有条件
		if (condition != null && !condition.equals("")) {
			// 过滤
			this.filterByCondition(condition);
		}
		// 看记录是否根据数据来源显示
		String source = this.component.getElement().getAttribute("datasource");
		// 如果值为true,说明按数据来源显示
		if (source != null && source.equals("true")) {
			// 取实体类型
			LinkedList ls = EntityManager.getInstance().getObjects(
					"com.browsesoft.resource.UniversalResourceEntity", "name",
					entityType);
			// 如果有实体类型
			if (ls.size() == 1) {
				Resource res = (Resource) ls.get(0);
				// 得到用户的权限
				Collection con = ResourceTool.getUserRights(loginUser, res);
				// 得到权限对应的数据
				this.datas = this.getRightDatas(con);
			}
		}
		// 得到查询条件名,和值
		List l = ExtendElement.findElements(this.component.getPage()
				.getElement(), "name", "selectsearch");
		// 没有下拉查询条件项，返回
		if (l.size() != 1) {
			return;
		}
		Element elem = (Element) l.get(0);
		// 得到查询条件名
		String condName = elem.getAttribute("condname");
		String allValue = elem.getAttribute("allvalue");
		// 得到查询条件值
		String condValue = request.getParameter("selectsearch");
		// 如果值不为空
		if (condName != null && !condName.equals("") && condValue != null
				&& !condValue.equals("") && !condValue.equals(allValue)) {
			condValue = condValue.replaceAll("　", "");
			condValue = condValue.trim();
			// 根据条件得到数据
			this.datas = this.getDatasByType(condName, condValue);
		}
	}

	/**
	 * 得到不含条件的数据
	 * 
	 * @param request
	 * @throws Exception
	 */
	private List getData(HttpServletRequest request) throws Exception {
		List result;
		// 如果父id为空
		if (parentID == null) {
			parentID = request.getParameter("point");
		}
		if (parentID != null && this.entityType != null) {
			// 取所有数据
			result = EntityManager.getInstance().getEntities(this.entityType,
					"parentid", this.parentID, this.formElement);
		}
		// 如果父id为空
		else if (parentID == null) {
			// 取所有数据
			result = EntityManager.getInstance().getEntities(this.entityType,
					this.formElement);
		}
		// 有父id
		else {
			// 取父下所有数据
			result = EntityManager.getInstance().getObjects(
					"com.browsesoft.baseadapter.SimpleEntity", "parentid",
					parentID);
		}
		return result;
	}

	/**
	 * 插入编号
	 * 
	 * @param it
	 *            迭代器
	 * @param map
	 *            属性集合
	 * @throws Exception
	 */
	protected void insertSerialNumber(Iterator it, Map map) throws Exception {
		while (it.hasNext()) {
			// 得到id号
			String name = (String) it.next();
			// 从管理器中得到该对象
			Entity entity = (Entity) EntityManager.getInstance()
					.getObject(name);
			if (this.datas.contains(entity)) {
				// 得到用户输入的值
				String value = ((String[]) map.get(name))[0];
				entity.getAttributes().put("f_serialnumber", value);
				entity.update();
			}
		}
	}

	/**
	 * 根据列表值得到某一类型的数据
	 * 
	 * @param value
	 *            列表值
	 * @return 某一类型的数据
	 * @throws Exception
	 */
	protected LinkedList getDatasByType(String name, String value)
			throws Exception {
		LinkedList list = new LinkedList();
		Hashtable ht = new Hashtable();
		ht.put(name, value);
		// 得到此类的所有数据
		LinkedList ls = EntityManager.getInstance().getObjects(
				"com.browsesoft.baseadapter.SimpleEntity", ht);
		Iterator iter = ls.iterator();
		// 对于每一个
		while (iter.hasNext()) {
			Object item = iter.next();
			// 如果有
			if (this.datas.contains(item)) {
				// 添加到链表中
				list.add(item);
			}
		}
		return list;
	}

	/**
	 * 得到权限对应的数据
	 * 
	 * @param con
	 *            操作权限
	 * @return 权限对应的数据
	 */
	private LinkedList getRightDatas(Collection con) {
		LinkedList result = new LinkedList();
		// 权限对应的数据
		Iterator iter = datas.iterator();
		// 如果有下一个
		while (iter.hasNext()) {
			Entity item = (Entity) iter.next();
			// 取数据来源
			String orgName = (String) item.getAttributes().get(
					"f_organizationname");
			Iterator it = con.iterator();
			if (orgName == null) {
				result.add(item);
			}
			// 如果有操作权限
			else if (getIsHasRight(it, orgName)) {
				result.add(item);
			}
		}
		return result;
	}

	/**
	 * 得到是否有操作权限
	 * 
	 * @param iter
	 *            操作权限
	 * @param name
	 *            数据来源
	 * @return 是否有操作权限
	 */
	private boolean getIsHasRight(Iterator iter, String name) {
		// 对于每一个操作权限
		while (iter.hasNext()) {
			Right right = (Right) iter.next();
			RightType rightType = new RightType(name);
			// 如果操作权限=数据来源
			if (right.getType() != null &&

			right.getType().equals(rightType)) {
				return true;
			}
		}
		return false;
	}

	/**
	 * 根据条件过滤
	 * 
	 * @param condition
	 */
	protected void filterByCondition(String condition) {
		Collection result = new LinkedList();
		// 对于每一个实体
		Iterator it = this.datas.iterator();
		while (it.hasNext()) {
			Entity entity = (Entity) it.next();
			// 如果满足条件
			if (isTrues(entity, condition)) {
				// 加到结果中去
				result.add(entity);
			}
		}
		this.datas = (LinkedList) result;
	}

	/**
	 * 设置查询条件
	 * 
	 * @param condition
	 *            条件
	 */
	public void setCondition(Hashtable condition) {
		// 将自己的查询条件清空
		this.condition.clear();
		this.condition.putAll(condition);
	}

	/**
	 * 设置查询条件
	 * 
	 * @param condition
	 *            条件
	 */
	public void setCondition(String condition) {
	}

	/**
	 * 得到查询条件
	 * 
	 * @return 条件
	 */
	public Hashtable getCondition() {
		return this.condition;
	}

	/**
	 * 得到某列的操作类型
	 * 
	 * @param col
	 *            col
	 * @return 类型
	 */
	public String getType(int col) {
		if (col < cnames.size()) {
			return "td";
		}
		return null;
	}

	/**
	 * 修改单元值
	 * 
	 * @param td
	 *            td
	 * @param doc
	 *            doc
	 * @param row
	 *            row
	 * @param col
	 *            col
	 */
	public void modifyCellValue(Element td, Document doc, int row, int col) {
		try {
			Entity entity = this.getOneRow(row);
			// 如果配置有列显示条件，判断是否能显示
			if (cellDisplayProcess(td, doc, row, col, entity)) {
				return;
			}
			// 否则一般处理
			this.setCellValue(entity, td, doc, row, col);
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}

	public boolean cellDisplayProcess(Element td, Document doc, int row,
			int col, Entity entity) throws InstantiationException,
			IllegalAccessException, ClassNotFoundException, Exception {
		if (!hasCondition(td)) {
			return false;
		}
		// 得到配置的条件类
		String conditionClassName = td.getAttribute("conditionclass");
		Condition condition = (Condition) Class.forName(conditionClassName)
				.newInstance();
		// 如果可显示
		if (!condition.isTrue(entity, td)) {
			ExtendElement.removeChilds(td);
			ExtendElement.replaceElementContext(td, "　");
			return true;
		}
		return false;
	}

	/**
	 * 设置单元格
	 */
	private void setCellValue(Entity entity, Element td, Document doc, int row,
			int col) throws Exception {
		// 如果有行标记
		if (hasRowNumber()) {
			if (col == 0) {
				ExtendElement.replaceElementContext(td, doc.createTextNode(""
						+ (row +

						1)));
			} else if (col < cnames.size() + 1) {
				this.replace(entity, col - 1, td, doc);
			} else {
				// 替换td中属性值
				this.replaceTD(td, entity);
			}
		} else {
			// 显示名字
			if (col < cnames.size()) {
				this.replace(entity, col, td, doc);
			} else {
				// 替换td中属性值
				this.replaceTD(td, entity);
			}
		}
	}

	/**
	 * 判断改列元素是否配置有条件类
	 */
	private boolean hasCondition(Element td) {
		String condition = td.getAttribute("conditionclass");
		if (condition != null && !condition.equals("")) {
			return true;
		}
		return false;
	}

	/**
	 * 替换td中属性值
	 * 
	 * @param entity
	 * @param col
	 * @param td
	 * @param doc
	 */
	protected void replace(Entity entity, int col, Element td, Document doc)
			throws Exception {
		// 替换id
		this.replaceTD(td, entity);
		// 替换要显示的内容
		// 属性名
		String ename = (String) enames.get(col);
		String showContent = "";
		if (this.fieldExpress.containsKey(ename)) {
			showContent = getExpValue(ename, entity.getAttributes());
		} else {
			// 属性值
			showContent = (String) entity.getAttributes().get(ename);
		}
		if (showContent == null) {
			showContent = "　";
		}
		// 设置居左居右属性值
		Node formNode = (Node) ExtendElement.findElementContext(td).get(0);
		Element parent = (Element) formNode.getParentNode();
		String tdalign = (String) bsalign.get(col);
		if (tdalign.equals("left") || tdalign.equals("right")
				|| tdalign.equals("center")) {
			parent.setAttribute("align", tdalign);
		} else {
			parent.setAttribute("align", "center");
		}
		// 替换
		ExtendElement.replaceElementContext(td,

		doc.createTextNode(showContent));
	}

	/**
	 * 得到表达式处理记过
	 */
	private String getExpValue(String ename, Hashtable attrs) {
		throw new UnsupportedOperationException();
	}

	/**
	 * 得到一行数据
	 * 
	 * @param row
	 *            行号
	 */
	public Entity getOneRow(int row) {
		return (Entity) datas.get(row);
	}

	/**
	 * 替换元素
	 * 
	 * @param td
	 *            element
	 * @param entity
	 *            实体
	 */
	protected void replaceTD(Element td, com.browsesoft.Entity entity) {
		// 取出所有带链接的元素
		LinkedList nl = ExtendElement.findElements(td, "type", "link");
		// 如果有链接
		if (nl.size() != 0) {
			Element link = (Element) nl.get(0);
			// 替换参数值
			String onclick = link.getAttribute("onclick");
			onclick = this.replaceOnClick(entity, onclick);
			link.setAttribute("onclick", onclick);
			String href = link.getAttribute("href");
			if (href != null && !href.equals("")) {
				href = replaceOnClick(entity, href);
				link.setAttribute("href", href);
			}
		}
		// 取出所有checkbox元素
		nl = ExtendElement.findElements(td, "type", "checkbox");
		if (nl.size() != 0) {
			// 得到第一个元素
			Element checkbox = (Element) nl.get(0);
			this.replaceCheckbox(checkbox, entity);
		}
		// 取出所有serialnumber元素(设置对象编号的input框)
		nl = ExtendElement.findElements(td, "serialnumber", "serialnumber");
		if (nl.size() != 0) {
			Element input = (Element) nl.get(0);
			this.replaceSerialNumber(input, entity);
		}
		// 得到td中的条件
		String condition = td.getAttribute("condition");
		// 如果有条件,且条件不满足
		if (condition != null && !condition.equals("")
				&& !isTrues(entity, condition)) {
			// 清空内容
			ExtendElement.removeChilds(td);
			// 添加全角空格，以便显示表格线
			Text text = td.getOwnerDocument().createTextNode("　");
			td.appendChild(text);
		}
	}

	/**
	 * 替换对象编号的输入框
	 * 
	 * @param input
	 *            输入框
	 * @param entity
	 *            对应的实体
	 */
	protected void replaceSerialNumber(Element input, Entity entity) {
		String id = (String) entity.getAttributes().get("id");
		input.setAttribute("name", id);
		// 得到实体的属性
		String value = (String)

		entity.getAttributes().get("f_serialnumber");
		// 如果属性为空
		if (value == null || value.equals("")) {
			// 赋空串
			value = "";
		}
		// 设置属性值
		input.setAttribute("value", value);
	}

	/**
	 * 替换checkbox
	 * 
	 * @param checkbox
	 * @param entity
	 */
	protected void replaceCheckbox(Element checkbox, Entity entity) {
		String id = (String) entity.getAttributes().get("id");
		checkbox.setAttribute("name", id);
		// 如果被选择，设置check框被选择
		if (this.changed.contains(id)) {
			checkbox.setAttribute("checked", "checked");
		}
		// 替换onclick方法的参数值
		String onclick = checkbox.getAttribute("onclick");
		// 如果有onclidk属性
		if (onclick != null && !onclick.equals("")) {
			onclick = this.replaceOnClick(entity, onclick);
			checkbox.setAttribute("onclick", onclick);
		}
	}

	/**
	 * 用实际值替换onclick中的参数值
	 */
	protected String replaceParams(Entity entity, String onClick) {
		String[] sub = onClick.split("#");
		for (int i = 0; i < sub.length; i++) {
			// 得到有效的参数
			if (i % 2 == 1) {
				// 参数名
				String name = sub[i];
				// 如果存在该属性
				if (entity.getAttributes().containsKey(name)) {
					// 参数值
					String value = (String)

					entity.getAttributes().get(name);
					if (value != null) {
						// 用参数值替换参数名
						onClick = onClick.replaceAll("#" +

						name + "#", value);
					}
				}
			}
		}
		return onClick;
	}

	/**
	 * 换OnClick内容
	 * 
	 * @param entity
	 *            对应的实体
	 * @param onClick
	 *            onClick属性值
	 * @return
	 */
	protected String replaceOnClick(Entity entity, String onClick) {
		onClick = this.replaceParams(entity, onClick);
		String id = (String) entity.getAttributes().get("id");
		// 替换id
		onClick = onClick.replaceAll("#nodeid#", id);
		onClick = onClick.replaceAll("#parentid#", this.parentID);
		int index = onClick.indexOf("result");
		// 如果有result
		if (index != -1) {
			// 替换为组件名
			onClick = onClick.replaceAll("result", "resultdarpent_"
					+ this.component.getName());
		}
		return onClick;
	}

	/**
	 * 看给定实体是否满足多个条件,条件包括带感叹号的和实体实现的方法
	 * 
	 */
	protected boolean isTrues(Entity entity, String condition) {
		// 多个过滤条件用“;”号分开，把条件转换为链表
		LinkedList conditions = Tools.stringToLinkedList(condition, ';');
		Iterator it = conditions.iterator();
		while (it.hasNext()) {
			String cond = (String) it.next();
			if (!isTrue(entity, cond)) {
				return false;
			}
		}
		return true;
	}

	/**
	 * 看给定实体是否满足条件,条件包括带感叹号的
	 * 
	 */
	protected boolean isTrue(Entity entity, String condition) {
		try {
			// 得到方法
			Class[] param = {};
			Object[] o = {};
			Method m = null;
			int pos = condition.indexOf("(");
			// 有参数
			if (pos != -1) {
				// 参数
				String params = condition.substring(pos + 1,

				condition.indexOf(")"));
				LinkedList ls = Tools.stringToLinkedList(params);
				Iterator iter = ls.iterator();
				param = new Class[ls.size()];
				o = new Object[ls.size()];
				int i = 0;
				// 每个参数
				while (iter.hasNext()) {
					String item = (String) iter.next();
					param[i] = item.getClass();
					o[i] = item;
					i++;
				}
				// 如果condition带感叹号,取感叹号后的方法
				if (condition.startsWith("!")) {
					m = entity.getClass().getMethod(
							condition.substring(1, pos), param);
				}
				// 否则,取condition对应的方法
				else {
					m = entity.getClass().getMethod(
							condition.substring(0, pos), param);
				}
			}
			// 无参数
			else {
				// 如果condition带感叹号,取感叹号后的方法
				if (condition.startsWith("!")) {
					m = entity.getClass().getMethod(condition.substring(1),
							param);
				}
				// 否则,取condition对应的方法
				else {
					m = entity.getClass().getMethod(condition, param);
				}
			}
			if (entity instanceof SimpleEntity) {
				((SimpleEntity) entity).setLoginUser(this.loginUser);
			}
			// 执行方法
			Boolean b = (Boolean) m.invoke(entity, o);
			// 如果condition带感叹号,取返
			if (condition.startsWith("!")) {
				return !b.booleanValue();
			}
			return b.booleanValue();
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}

	/**
	 * 设置模型所对应的组件
	 * 
	 * @param component
	 *            对应的组件
	 */
	public void setComponent(HTMLBasicComponent component) {
		this.component = component;
		// 得到过滤器
		this.filter = this.getFilter(component.getElement());
	}

	/**
	 * 模型更新页面元素
	 * 
	 * @param c
	 *            基本组件
	 * @throws Exception
	 */
	public void updatePageElement(HTMLBasicComponent c) throws Exception {
		// 显示数据总数
		this.showRowCount();
	}

	/**
	 * 显示数据的总数
	 * 
	 */
	public void showRowCount() {
		// 得到行数
		String count = Integer.toString(this.datas.size());
		// 得到count元素
		NodeList nl = this.component.getElement().getElementsByTagName("count");
		if (nl.getLength() > 0) {
			Element e = (Element) nl.item(0);
			// 替换元素内容
			ExtendElement.replaceElementContext(e, this.component.getElement()
					.getOwnerDocument().createTextNode(count));
		}
	}

	/**
	 * 得到Form表单元素
	 */
	private Element getFormElement() {
		try {
			// 得到组件元素中的form属性值，用来
			Element formElement = (Element) this.component.getElement();
			// 得到模板名
			String templatename = formElement.getAttribute("form");
			// 如果form属性值不存在，返回空
			if (templatename == null || templatename.equals("")) {
				return null;
			}
			// 由form属性值生成页面
			Template t = TemplateManager.getInstance().getTemplateByName(
					templatename);
			// 得到模板文档,
			Document document = t.getDocument();
			// 解析文档,找出需要处理的根元素
			NodeList nl = document.getElementsByTagName("form");
			Element root = (Element) nl.item(0);
			return root;
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}

	/**
	 * 得到要显示的名称，和实体类型
	 * 
	 * @throws Exception
	 */
	private void getTemplate(Element root) throws Exception {
		// 找到所有显示的组件
		LinkedList v = ExtendElement.findElements(root, "show", "show");
		Iterator iter = v.iterator();
		// 每个元素
		while (iter.hasNext()) {
			Element element = (Element) iter.next();
			// 添加英文名
			String ename = element.getAttribute("name");
			enames.add(ename);
			// 添加中文名
			cnames.add(element.getAttribute("cname"));
			// 添加居左居右
			bsalign.add(element.getAttribute("bsalign"));
			// 如果配置有showexp="showexp" 获取其表达式配置
			if (element.hasAttribute("showexp")) {
				this.fieldExpress.put(ename, element);
			}
			// 添加元素
			elements.add(element);
		}
	}

	/**
	 * 删除
	 */
	protected void deleteEntity(HttpServletRequest request, String action,
			HTMLBasicComponent com) throws Exception {
		// 取得本次Check框的变化结果
		String re = request.getParameter("resultdarpent" + "_" + com.getName());
		// 对于每一个变化了的Check框
		LinkedList v = Tools.stringToLinkedList(re);
		for (int i = 0; i < v.size(); i++) {
			// 如果Check框上次已在变化集合中
			if (this.changed.contains(v.get(i))) {
				// 从变化集合中删除
				this.changed.remove(v.get(i));
			}
			// 否则
			else {
				// 添加该变化
				this.changed.add(v.get(i));
			}
		}
		// 如果action="deletedmail",则执行彻底删除邮件操作
		if (action != null && changed.size() > 0
				&& action.equals("deletedmail")) {
			// 删除邮件
			MoreDelete.getinstance().deleteMailS(changed);
			changed.clear();
		}
		// 如果真正提交，且有变化内容
		if (action != null && changed.size() > 0
				&& action.equals("deleteselected")) {
			// 删除所选择的实体
			this.deleteEntities(changed);
			changed.clear();
		}
		if (action != null && changed.size() > 0 && action.equals("mailchange")) {
			String name = request.getParameter("selectfolder");
			if (name != null) {
				if (!name.equals("请选择文件夹")) {
					this.moveMail(changed, name);
				}
			}
		}
	}

	/**
	 * 删除选中的实体
	 */
	private void deleteEntities(List entities) {
		Iterator iter = entities.iterator();
		while (iter.hasNext()) {
			String id = (String) iter.next();
			Entity e = this.getEntity(id);
			try {
				e.delete();
			} catch (Exception e1) {
				throw new RuntimeException(e1);
			}
		}
	}

	/**
	 * 从数据区找到编号为id的对象
	 */
	private Entity getEntity(String id) {
		Iterator iter = this.datas.iterator();
		while (iter.hasNext()) {
			Entity e = (Entity) iter.next();
			if (e.getID().equals(id)) {
				return e;
			}
		}
		return null;
	}

	private void moveMail(LinkedList changed, String name) throws Exception {
	}

	/**
	 * 实现数据排序
	 */
	public void SortDatas() {
		// 从页面中得到排序的字段名
		String orderByName = this.component.getElement().getAttribute(
				"orderbyname");
		String order = this.component.getElement().getAttribute("order");
		if (orderByName != null && !orderByName.equals("")) {
			Collections.sort(datas, new ComparatorByName(orderByName,

			order));
		} else if (order.equals("desc")) {
			Collections.reverse(datas);
		}
	}

	/**
	 * 通过指定字段名，按升序或或者降序排序
	 * 
	 * @version 1.0
	 */
	class ComparatorByName implements Comparator {
		/**
		 * 字段名
		 */
		String fieldName = null;

		/**
		 * 排序方式
		 */

		String orderName = null;

		/**
		 * 构造器
		 * 
		 * @param orderByName
		 *            字段名
		 * @param order
		 *            升序asc ;降序desc
		 */

		public ComparatorByName(String orderByName, String order) {
			this.fieldName = orderByName;
			this.orderName = order.toLowerCase();
		}

		public int compare(Object o1, Object o2) {
			Entity e1 = (Entity) o1;
			Entity e2 = (Entity) o2;
			String s1 = (String) e1.getAttributes().get(fieldName);
			String s2 = (String) e2.getAttributes().get(fieldName);
			if (s1 == null) {
				s1 = "";
			}
			if (s2 == null) {
				s2 = "";
			}
			if (orderName.equals("desc")) {
				return 0 - s1.compareTo(s2);
			}
			return s1.compareTo(s2);
		}
	}

	/**
	 * 得到栏目信息个数
	 */
	public int getCount() {
		return this.datas.size();
	}

	/**
	 * 得到某行内容
	 */
	public String getContext(int row) {
		return this.datas.get(row).toString();
	}

	/**
	 * 得到单击动作
	 */
	public String getMouseClick(int row) {
		return "alert('ok')";
	}

	/**
	 * 得到工具
	 */
	public List getTools(int row) {
		return new LinkedList();
	}

	/**
	 * 从组件元素中得到过滤器，如果没有配置，则返回空
	 */
	private LookFilter getFilter(Element e) {
		String cname = e.getAttribute("filter");
		if (cname != null && !cname.equals("")) {
			try {
				return (LookFilter) Class.forName(cname).newInstance();
			} catch (InstantiationException e1) {
				throw new RuntimeException(e1);
			} catch (IllegalAccessException e1) {
				throw new RuntimeException(e1);
			} catch (ClassNotFoundException e1) {
				throw new RuntimeException(e1);
			}
		}
		return null;
	}

	/**
	 * 得到变化集合
	 */
	public Collection getChanged() {
		return this.changed;
	}

	/**
	 * 从模型数据中得到给定属性名=属性值的头一个对象
	 */
	protected Entity getEntity(String name, String value) {
		Iterator iter = this.datas.iterator();
		while (iter.hasNext()) {
			Entity entity = (Entity) iter.next();
			String eValue = (String) entity.getAttributes().get(name);
			if (eValue != null && eValue.equals(value)) {
				return entity;
			}
		}
		return null;
	}
}